package com.wicket.okrapp.biz.service.impl;

import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;

import javax.annotation.Resource;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.base.service.MOmsEvaluationObjectTargetCycleService;
import com.wicket.okrapp.base.service.MOmsTargetService;
import com.wicket.okrapp.dal.po.mbg.OmsTarget;
import com.wicket.okrapp.base.service.dto.req.QueryTargetDetailReq;
import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrapp.biz.service.nb.NbConventionalScheduling;
import com.wicket.okrapp.base.service.MOmsEvaBatchRelatedSetService;
import com.wicket.okrapp.base.service.MOmsTargetTimingTaskDispatchService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetTimingTaskDispatch;
import com.wicket.okrapp.base.service.dto.req.QueryTimerTaskPlanDetailReq;
import com.wicket.okrapp.biz.service.dto.common.TargetContentDto;

import java.util.concurrent.Callable;
import com.wicket.okrcomponent.integration.FwCompDivineDataClient;
import com.wicket.okrapp.biz.service.TimingTaskService;
import com.wicket.okrapp.base.service.MOmsTaskService;
//import com.wicket.okrapp.biz.service.dto.common.ReportingTaskDto;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationObjectTargetCycle;
import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleDetailReq;
import com.wicket.okrapp.base.service.MOmsEvaluationTemplateService;
import com.wicket.okrapp.biz.service.TaskGenService;
import com.wicket.okrapp.biz.service.dto.common.ReportingTaskDto;
import com.wicket.okrapp.dal.po.mbg.OmsTask;
import com.wicket.okrapp.base.service.dto.req.QueryTaskDetailReq;
import com.wicket.okrapp.biz.service.IndexSystemService;
import com.wicket.okrcomponent.integration.dto.ImplementComparisonOfMultipleTimeTypesComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementComparisonOfMultipleTimeTypesComReqDto;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrapp.biz.service.TargetContentService;
import com.wicket.okrapp.biz.service.TaskService;
import com.wicket.okrapp.biz.service.InterfaceModeService;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class ConventionalSchedulingServiceImpl
  implements com.wicket.okrapp.biz.service.ConventionalSchedulingService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private MOmsTargetService mOmsTargetService;
@Resource
  private NbConventionalScheduling nbConventionalScheduling;
//@Resource
 //private undefinedService undefinedService;
@Resource
  private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
@Resource
  private MOmsTargetTimingTaskDispatchService mOmsTargetTimingTaskDispatchService;
@Resource
  private FwCompDivineDataClient fwCompDivineDataClient;
@Resource
  private TimingTaskService timingTaskService;
@Resource
  private MOmsTaskService mOmsTaskService;
@Resource
  private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
@Resource
  private TaskGenService taskGenService;
@Resource
  private IndexSystemService indexSystemService;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private TargetContentService targetContentService;
@Resource
  private TaskService taskService;
@Resource
  private InterfaceModeService interfaceModeService;
//@Resource
 //private MCustomFields3Service mCustomFields3Service;
/**
   * D3-执行调度是否可以执行判断(公共)[6606]
   * gen by moon at 6/6/2023, 1:40:33 AM
   */
  @Trace(operationName = "D3-执行调度是否可以执行判断(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSchedulingCanBeExecuteComRespDto implementSchedulingCanBeExecuteCom(ImplementSchedulingCanBeExecuteComReqDto reqDto){
    
      
      CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 =null;
//virtualUsage 约定：是  41243
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setTureOrFalse("TRUE");//sourceId:928311_1_41243
  
    /*约定：是[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTureOrFalse(),"D3-执行调度是否可以执行判断(公共)-约定：是-是否不能为空",false);
      receptionServiceRes = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq);
      
      
      
//virtualUsage 约定：否  41244
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:928412_1_41244
  
    /*约定：否[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTureOrFalse(),"D3-执行调度是否可以执行判断(公共)-约定：否-是否不能为空",false);
      receptionServiceRes_2 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_1);
      
      
      
if((reqDto!= null&&  reqDto.getDispatchActionTypeCode() !=null && reqDto.getDispatchActionTypeCode().equals("STAGE_CURRENT_CYCLE_ETC"))) {
        //if(D3-执行调度是否可以执行判断(公共).任务调度的行为类型编码 等于 调度更新执行周期阶段当前周期等（选用）)  41237
        
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:928547_1_41378
    }
  
    /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getTureOrFalse(),"D3-执行调度是否可以执行判断(公共)-约定出参：是否可用-是否不能为空",false);
      receptionServiceRes_4 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_2);
      
      
      receptionServiceRes_5 = receptionServiceRes_4;
      }
else if((reqDto!= null&&  reqDto.getDispatchActionTypeCode() !=null && reqDto.getDispatchActionTypeCode().equals("FOUR_TREE_DEVIATION_DAYS_ETC")||reqDto!= null&&  reqDto.getDispatchActionTypeCode() !=null && reqDto.getDispatchActionTypeCode().equals("TIMING_TASK_AUTO_UPDATE_WEIGHT_SCORE"))){
       //elseif((D3-执行调度是否可以执行判断(公共).任务调度的行为类型编码 等于 调度更新四棵树偏差天数等数据（选用） or D3-执行调度是否可以执行判断(公共).任务调度的行为类型编码 等于 调度自动更新权重分))  41379

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:929880_1_41380
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:929882_1_41380
queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:929877_1_41380
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:929879_1_41380
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1012244_1_41380
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:929875_1_41380
queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:929876_1_41380
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:929878_1_41380
    }

    /*3-3-09查目标内容父周期进展状态是否完成[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3-执行调度是否可以执行判断(公共)-3-3-09查目标内容父周期进展状态是否完成-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3-执行调度是否可以执行判断(公共)-3-3-09查目标内容父周期进展状态是否完成-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3-执行调度是否可以执行判断(公共)-3-3-09查目标内容父周期进展状态是否完成-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-执行调度是否可以执行判断(公共)-3-3-09查目标内容父周期进展状态是否完成-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3-执行调度是否可以执行判断(公共)-3-3-09查目标内容父周期进展状态是否完成-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getTaskStatus() !=null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("NOT_AT_THE")||omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getTaskStatus() !=null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("ONGOING"))) {
        //if((3-3-09查目标内容父周期进展状态是否完成.目标周期任务进展状态 等于 未开始 or 3-3-09查目标内容父周期进展状态是否完成.目标周期任务进展状态 等于 进行中))  41381
      
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:928547_1_41382
    }
  
    /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getTureOrFalse(),"D3-执行调度是否可以执行判断(公共)-约定出参：是否可用-是否不能为空",false);
      receptionServiceRes_6 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_3);
      
      
      receptionServiceRes_5 = receptionServiceRes_6;
    }
else if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getTaskStatus() !=null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("HAS_ENDED"))){
       //elseif(3-3-09查目标内容父周期进展状态是否完成.目标周期任务进展状态 等于 已结束)  41383

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_4=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_4.setTureOrFalse(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:928547_1_41390
    }

    /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getTureOrFalse(),"D3-执行调度是否可以执行判断(公共)-约定出参：是否可用-是否不能为空",false);
      receptionServiceRes_7 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_4);


      receptionServiceRes_5 = receptionServiceRes_7;
    }
    }
else if((reqDto!= null&&  reqDto.getDispatchActionTypeCode() !=null && reqDto.getDispatchActionTypeCode().equals("TASK_OVERDUE_ETC"))){
       //elseif(D3-执行调度是否可以执行判断(公共).任务调度的行为类型编码 等于 调度更新任务逾期等数据（选用）)  41384

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:929866_1_41385
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:929864_1_41385
queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:929865_1_41385
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTargetCycleId(),"D3-执行调度是否可以执行判断(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3-执行调度是否可以执行判断(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(),"D3-执行调度是否可以执行判断(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaluationObjectTargetCycle_2!= null&&  omsEvaluationObjectTargetCycle_2.getTaskStatus() !=null && omsEvaluationObjectTargetCycle_2.getTaskStatus().equals("NOT_AT_THE")||omsEvaluationObjectTargetCycle_2!= null&&  omsEvaluationObjectTargetCycle_2.getTaskStatus() !=null && omsEvaluationObjectTargetCycle_2.getTaskStatus().equals("ONGOING"))) {
        //if((3-3-09查目标周期进展状态是否已完成.目标周期任务进展状态 等于 未开始 or 3-3-09查目标周期进展状态是否已完成.目标周期任务进展状态 等于 进行中))  41386

OmsTask omsTask = null;
    QueryTaskDetailReq queryTaskDetailReq=new QueryTaskDetailReq();
  queryTaskDetailReq.setIsArchive("FALSE");//sourceId:940728_1_41690
if(reqDto!=null){
      queryTaskDetailReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:940723_1_41690
queryTaskDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:940727_1_41690
    }

    /*3-7-01查询任务详情[2522]   */
    Assert.isNull(queryTaskDetailReq.getTaskId(),"D3-执行调度是否可以执行判断(公共)-3-7-01查询任务详情-任务ID不能为空",false);
Assert.isNull(queryTaskDetailReq.getThemeContentId(),"D3-执行调度是否可以执行判断(公共)-3-7-01查询任务详情-主题内容ID不能为空",false);
Assert.isNull(queryTaskDetailReq.getIsArchive(),"D3-执行调度是否可以执行判断(公共)-3-7-01查询任务详情-是否存档不能为空",false);
      omsTask = mOmsTaskService.queryTaskDetail(queryTaskDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTask!= null&&  omsTask.getIsComplete() !=null && omsTask.getIsComplete().equals("FALSE"))) {
        //if(3-7-01查询任务状态.是否完成 等于 否)  41691

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_8 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_5=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_5.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:928547_1_41692
    }

    /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getTureOrFalse(),"D3-执行调度是否可以执行判断(公共)-约定出参：是否可用-是否不能为空",false);
      receptionServiceRes_8 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_5);


      receptionServiceRes_5 = receptionServiceRes_8;
      }
else if((omsTask!= null&&  omsTask.getIsComplete() !=null && omsTask.getIsComplete().equals("TRUE"))){
       //elseif(3-7-01查询任务状态.是否完成 等于 是)  41693

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_9 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_6=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_6.setTureOrFalse(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:928547_1_41694
    }

    /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_6.getTureOrFalse(),"D3-执行调度是否可以执行判断(公共)-约定出参：是否可用-是否不能为空",false);
      receptionServiceRes_9 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_6);


      receptionServiceRes_5 = receptionServiceRes_9;
    }
    }
else if((omsEvaluationObjectTargetCycle_2!= null&&  omsEvaluationObjectTargetCycle_2.getTaskStatus() !=null && omsEvaluationObjectTargetCycle_2.getTaskStatus().equals("HAS_ENDED"))){
       //elseif(3-3-09查目标周期进展状态是否已完成.目标周期任务进展状态 等于 已结束)  41388

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_10 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_7=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_7.setTureOrFalse(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:928547_1_41389
    }

    /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_7.getTureOrFalse(),"D3-执行调度是否可以执行判断(公共)-约定出参：是否可用-是否不能为空",false);
      receptionServiceRes_10 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_7);


      receptionServiceRes_5 = receptionServiceRes_10;
    }
    }
ImplementSchedulingCanBeExecuteComRespDto retData = new ImplementSchedulingCanBeExecuteComRespDto();
  if(receptionServiceRes_5!=null){
      retData.setTureOrFalse(receptionServiceRes_5.getTureOrFalse());//SimpleFieldAssign//sourceId:928801_1
    }
  

  
  
return retData;
  }
/**
   * D3-执行四棵树偏差天数等数据(公共)[6602]
   * gen by moon at 5/12/2023, 3:13:16 AM
   */
  @Trace(operationName = "D3-执行四棵树偏差天数等数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementFourTreeDeviationDaysEtcComRespDto implementFourTreeDeviationDaysEtcCom(ImplementFourTreeDeviationDaysEtcComReqDto reqDto){
    
//
//      //virtualUsage M3异步开始（特殊方法）  41276
//      //ModelCode: asynchronizationStart
//Callable<String> call = new Callable<String>() {
//
//    @Override
//    public String call() throws Exception {
//        //执行方法
////virtualUsage M3执行业务应用公共字段推送内存（特殊方法）  41324
//      OmsEvaBatchRelatedSet omsEvaBatchRelatedSet = null;
//    Object unknown=new Object();
//  if(reqDto!=null){
//      unknown.setCreateInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:929103_1_41324
//unknown.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:929104_1_41324
//unknown.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:929105_1_41324
//    }
//
//    /*M3执行业务应用公共字段推送内存（特殊方法）[4520]   */
//    Assert.isNull(unknown.getCreateInductionId(),"D3-执行四棵树偏差天数等数据(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建人就职记录ID 不能为空",false);
//Assert.isNull(unknown.getSpaceId(),"D3-执行四棵树偏差天数等数据(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建于空间ID不能为空",false);
//Assert.isNull(unknown.getAppId(),"D3-执行四棵树偏差天数等数据(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建于联盟应用ID不能为空",false);
//      omsEvaBatchRelatedSet = mOmsEvaBatchRelatedSetService.implementBizPublicFieldPushMemory(unknown)/*vcase invoke 本地 method 方法调用;*/;
//
//
//
////virtualUsage D3-执行调度是否可以执行判断(公共)  41278
//      ImplementSchedulingCanBeExecuteComRespDto implementSchedulingCanBeExecuteComRespDto = null;
//    ImplementSchedulingCanBeExecuteComReqDto implementSchedulingCanBeExecuteComReqDto=new ImplementSchedulingCanBeExecuteComReqDto();
//
//
//    /*D3-执行调度是否可以执行判断(公共)[6606]   */
//    Assert.isNull(implementSchedulingCanBeExecuteComReqDto.getTargetId(),"D3-执行四棵树偏差天数等数据(公共)-D3-执行调度是否可以执行判断(公共)-冗余目标ID不能为空",false);
//      implementSchedulingCanBeExecuteComRespDto = implementSchedulingCanBeExecuteCom(implementSchedulingCanBeExecuteComReqDto)/*vcase invoke 同服务,同domain*/;
//
//
//
//if((implementSchedulingCanBeExecuteComRespDto!= null&&  implementSchedulingCanBeExecuteComRespDto.getTureOrFalse() !=null && implementSchedulingCanBeExecuteComRespDto.getTureOrFalse().equals("TRUE")&&reqDto!= null&&  reqDto.getTargetContentList() !=null && reqDto.getTargetContentList().size()>0)) {
//        //if((D3-执查询目标是否可用.是否 等于 是 and D3-执行四棵树偏差天数等数据(公共).目标内容列表数据集条数 大于 0))  41282
//
////ModelCode: circulationCollections
//        for (TargetContentDto circulationCollectionsRes: reqDto.getTargetContentList()){
//
//CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
//    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
//  checkTimeScopeSearchComReqDto.setCurrentTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:928863_1_41287
//if(circulationCollectionsRes!=null){
//      checkTimeScopeSearchComReqDto.setCompareTime(circulationCollectionsRes.getOperateTime());//SimpleFieldAssign//sourceId:928865_1_41287
//    }
//
//    /*D2检查时间范围查询(公共)[3297]   */
//    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3-执行四棵树偏差天数等数据(公共)-D2检查时间范围查询(公共)-当前时间不能为空",false);
//Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3-执行四棵树偏差天数等数据(公共)-D2检查时间范围查询(公共)-比较时间不能为空",false);
//      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("BEFORE"))) {
//        //if(D2检查时间范围查询(公共).时间比较结果 等于 之前（小于）)  41288
//
//OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch = null;
//    QueryTimerTaskPlanDetailReq queryTimerTaskPlanDetailReq=new QueryTimerTaskPlanDetailReq();
//  queryTimerTaskPlanDetailReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:928913_1_41289
//queryTimerTaskPlanDetailReq.setDispatchActionTypeCode("FOUR_TREE_DEVIATION_DAYS_ETC");//sourceId:928914_1_41289
//queryTimerTaskPlanDetailReq.setObjectTypeCode("OMS_TARGET");//sourceId:928915_1_41289
//queryTimerTaskPlanDetailReq.setIsCompensateTask("FALSE");//sourceId:928918_1_41289
//queryTimerTaskPlanDetailReq.setIsComplete("FALSE");//sourceId:928919_1_41289
//if(circulationCollectionsRes!=null){
//      queryTimerTaskPlanDetailReq.setObjectId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:928916_1_41289
//queryTimerTaskPlanDetailReq.setThemeContentId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:928917_1_41289
//    }
//
//    /*3-2-09查询定时任务调度详情[3187]   */
//    Assert.isNull(queryTimerTaskPlanDetailReq.getTaskDispatchTypeCode(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-任务调度类型编码不能为空",false);
//Assert.isNull(queryTimerTaskPlanDetailReq.getDispatchActionTypeCode(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-任务调度的行为类型编码不能为空",false);
//Assert.isNull(queryTimerTaskPlanDetailReq.getObjectTypeCode(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-归属对象类型编码不能为空",false);
//Assert.isNull(queryTimerTaskPlanDetailReq.getObjectId(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-归属对象内容ID不能为空",false);
//Assert.isNull(queryTimerTaskPlanDetailReq.getThemeContentId(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-主题内容ID不能为空",false);
//Assert.isNull(queryTimerTaskPlanDetailReq.getIsCompensateTask(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-是否补偿任务不能为空",false);
//Assert.isNull(queryTimerTaskPlanDetailReq.getIsComplete(),"D3-执行四棵树偏差天数等数据(公共)-3-2-09查询定时任务调度详情-是否执行完成不能为空",false);
//      omsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanDetail(queryTimerTaskPlanDetailReq)/*vcase invoke 本地 method 方法调用;*/;
//
//
//
//if((omsTargetTimingTaskDispatch != null )) {
//        //if(3-2-09查询定时任务调度详情.出参 值不等于空 )  41290
//
//BatchRefreshTargetContentDeviationDaysEtcComRespDto batchRefreshTargetContentDeviationDaysEtcComRespDto = null;
//    if(omsTargetTimingTaskDispatch !=null){
//          BatchRefreshTargetContentDeviationDaysEtcComReqDto batchRefreshTargetContentDeviationDaysEtcComReqDto=new BatchRefreshTargetContentDeviationDaysEtcComReqDto();
//  if(omsTargetTimingTaskDispatch!=null){
//      batchRefreshTargetContentDeviationDaysEtcComReqDto.setTimingTaskDispatchId(omsTargetTimingTaskDispatch.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:927819_1_41291
//    }
//if(circulationCollectionsRes!=null){
//      batchRefreshTargetContentDeviationDaysEtcComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:927818_1_41291
//batchRefreshTargetContentDeviationDaysEtcComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:927817_1_41291
//batchRefreshTargetContentDeviationDaysEtcComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:927820_1_41291
//    }
//
//    /*D3-3批量更新目标内容偏差天数等数据(公共)[4724]   */
//    Assert.isNull(batchRefreshTargetContentDeviationDaysEtcComReqDto.getTimingTaskDispatchId(),"D3-执行四棵树偏差天数等数据(公共)-D3-3批量更新目标内容偏差天数等数据(公共)-定时任务调度记录ID不能为空",false);
//Assert.isNull(batchRefreshTargetContentDeviationDaysEtcComReqDto.getTargetCycleContentId(),"D3-执行四棵树偏差天数等数据(公共)-D3-3批量更新目标内容偏差天数等数据(公共)-关联目标内容ID不能为空",false);
//Assert.isNull(batchRefreshTargetContentDeviationDaysEtcComReqDto.getTargetCycleContentTypeCode(),"D3-执行四棵树偏差天数等数据(公共)-D3-3批量更新目标内容偏差天数等数据(公共)-关联目标内容类型编码不能为空",false);
//Assert.isNull(batchRefreshTargetContentDeviationDaysEtcComReqDto.getEvaluationTemplateId(),"D3-执行四棵树偏差天数等数据(公共)-D3-3批量更新目标内容偏差天数等数据(公共)-评价模板ID不能为空",false);
//      batchRefreshTargetContentDeviationDaysEtcComRespDto = timingTaskService.batchRefreshTargetContentDeviationDaysEtcCom(batchRefreshTargetContentDeviationDaysEtcComReqDto)/*vcase invoke isSameApp*/;
//
//
//
//           }
//      }
//      }
////ModelCode: circulationEnd
//        }
//
//      }
////virtualUsage M3异步结束（特殊方法）  41277
//      //ModelCode: asynchronizationEnd
//        return "";
//    }
//};
//CommonFunctionHelper.asynExcute(call);
ImplementFourTreeDeviationDaysEtcComRespDto retData = new ImplementFourTreeDeviationDaysEtcComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-执行周期当前子周期及末级周期调度(公共)[6603]
   * gen by moon at 9/8/2023, 2:14:43 AM
   */
  @Trace(operationName = "D3-执行周期当前子周期及末级周期调度(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementStageCurrentCycleEtcComRespDto implementStageCurrentCycleEtcCom(ImplementStageCurrentCycleEtcComReqDto reqDto){
    
//
//      //virtualUsage M3异步开始  41229
//      //ModelCode: asynchronizationStart
//Callable<String> call = new Callable<String>() {
//
//    @Override
//    public String call() throws Exception {
//        //执行方法
////virtualUsage M3业务应用公共字段推送内存  41273
//      //ModelCode: publicFieldCache
//        ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
//    ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq=new ImplementBizPublicFieldPushMemoryReqDto();
//  if(reqDto!=null){
//      publicFieldCacheReq.setCreateInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:928767_1_41273
//publicFieldCacheReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:928768_1_41273
//publicFieldCacheReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:928769_1_41273
//    }
//
//    /*M3业务应用公共字段推送内存[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
//    Assert.isNull(publicFieldCacheReq.getCreateInductionId(),"D3-执行周期当前子周期及末级周期调度(公共)-M3业务应用公共字段推送内存-创建人就职记录ID 不能为空",false);
//Assert.isNull(publicFieldCacheReq.getSpaceId(),"D3-执行周期当前子周期及末级周期调度(公共)-M3业务应用公共字段推送内存-创建于空间ID不能为空",false);
//Assert.isNull(publicFieldCacheReq.getAppId(),"D3-执行周期当前子周期及末级周期调度(公共)-M3业务应用公共字段推送内存-创建于联盟应用ID不能为空",false);
//      publicFieldCacheRes = nbConventionalScheduling.implementBizPublicFieldPushMemory(publicFieldCacheReq);
//
//
//
////virtualUsage 3-3-06查目标列表  41226
//      List<OmsTarget> listOmsTarget =new ArrayList<>();
//    QueryTargetListReq queryTargetListReq=new QueryTargetListReq();
//  queryTargetListReq.setDataInitStatus("TRUE");//sourceId:927855_1_41226
//queryTargetListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:927850_1_41226
//queryTargetListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:927851_1_41226
//
//    /*3-3-06查目标列表[2452]   */
//    Assert.isNull(queryTargetListReq.getDataInitStatus(),"D3-执行周期当前子周期及末级周期调度(公共)-3-3-06查目标列表-数据初始化完成状态不能为空",false);
//Assert.isNull(queryTargetListReq.getSubjectLifeCycle(),"D3-执行周期当前子周期及末级周期调度(公共)-3-3-06查目标列表-主体生命周期不能为空",false);
//Assert.isNull(queryTargetListReq.getSpaceId(),"D3-执行周期当前子周期及末级周期调度(公共)-3-3-06查目标列表-创建于空间ID不能为空",false);
//      listOmsTarget = mOmsTargetService.queryTargetList(queryTargetListReq)/*vcase invoke 本地 method 方法调用;*/;
//
//
//
//if((listOmsTarget!= null&&  listOmsTarget !=null && listOmsTarget.size()>0)) {
//        //if(3-3-06查目标列表.目标列表数据集条数 大于 0)  41227
//
////ModelCode: circulationCollections
//        for (OmsTarget circulationCollectionsRes: listOmsTarget){
//
//ImplementComparisonOfMultipleTimeTypesComRespDto implementComparisonOfMultipleTimeTypesComRespDto = null;
//    ImplementComparisonOfMultipleTimeTypesComReqDto implementComparisonOfMultipleTimeTypesComReqDto=new ImplementComparisonOfMultipleTimeTypesComReqDto();
//  implementComparisonOfMultipleTimeTypesComReqDto.setTimeUnitType("DAY");//sourceId:1118335_1_48420
//implementComparisonOfMultipleTimeTypesComReqDto.setCaluStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1118337_1_48420
//if(circulationCollectionsRes!=null){
//      implementComparisonOfMultipleTimeTypesComReqDto.setCompareTime(circulationCollectionsRes.getOperateTime());//SimpleFieldAssign//sourceId:1118336_1_48420
//    }
//
//    /*D2-执行多时间类型对比(公共)[7376]   */
//    Assert.isNull(implementComparisonOfMultipleTimeTypesComReqDto.getTimeUnitType(),"D3-执行周期当前子周期及末级周期调度(公共)-D2-执行多时间类型对比(公共)-时间单位类型不能为空",false);
//Assert.isNull(implementComparisonOfMultipleTimeTypesComReqDto.getCaluStartTime(),"D3-执行周期当前子周期及末级周期调度(公共)-D2-执行多时间类型对比(公共)-参照时间不能为空",false);
//Assert.isNull(implementComparisonOfMultipleTimeTypesComReqDto.getCompareTime(),"D3-执行周期当前子周期及末级周期调度(公共)-D2-执行多时间类型对比(公共)-比较时间不能为空",false);
//      implementComparisonOfMultipleTimeTypesComRespDto = fwCompInterfaceModeClient.implementComparisonOfMultipleTimeTypesCom(implementComparisonOfMultipleTimeTypesComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetPgsStatus() !=null && circulationCollectionsRes.getTargetPgsStatus().equals("NOT_AT_THE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetPgsStatus() !=null && circulationCollectionsRes.getTargetPgsStatus().equals("ONGOING"))&&(implementComparisonOfMultipleTimeTypesComRespDto!= null&&  implementComparisonOfMultipleTimeTypesComRespDto.getTimeCompareResult() !=null && implementComparisonOfMultipleTimeTypesComRespDto.getTimeCompareResult().equals("BEFORE"))) {
//        //if((M3执行目标【循环开始】.目标进展状态 等于 未开始 or M3执行目标【循环开始】.目标进展状态 等于 进行中) and D2-判断当天是否已经更新过当前周期.时间比较结果 等于 之前（小于）)  41256
//
//OmsEvaluationTemplate omsEvaluationTemplate = null;
//    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
//  queryEvaTempDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:934489_1_41542
//if(circulationCollectionsRes!=null){
//      queryEvaTempDetailReq.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:950588_1_41542
//    }
//
//    /*3-2-02查评价模板详情[2316]   */
//    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3-执行周期当前子周期及末级周期调度(公共)-3-2-02查评价模板详情-评价模板ID不能为空",false);
//Assert.isNull(queryEvaTempDetailReq.getSubjectLifeCycle(),"D3-执行周期当前子周期及末级周期调度(公共)-3-2-02查评价模板详情-主体生命周期不能为空",false);
//      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;
//
//
//
//QueryStageCurrentCycleDetailComRespDto queryStageCurrentCycleDetailComRespDto = null;
//    if(omsEvaluationTemplate !=null){
//          QueryStageCurrentCycleDetailComReqDto queryStageCurrentCycleDetailComReqDto=new QueryStageCurrentCycleDetailComReqDto();
//  queryStageCurrentCycleDetailComReqDto.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:934440_1_41539
//queryStageCurrentCycleDetailComReqDto.setDispatchActionTypeCode("STAGE_CURRENT_CYCLE_ETC");//sourceId:934441_1_41539
//queryStageCurrentCycleDetailComReqDto.setObjectTypeCode("OMS_TARGET");//sourceId:934442_1_41539
//queryStageCurrentCycleDetailComReqDto.setAddRuleInfoTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:934444_1_41539
//queryStageCurrentCycleDetailComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:934446_1_41539
////queryStageCurrentCycleDetailComReqDto.setIsCompensateTask("FALSE");//sourceId:934448_1_41539
////queryStageCurrentCycleDetailComReqDto.setIsComplete("FALSE");//sourceId:934449_1_41539
////queryStageCurrentCycleDetailComReqDto.setIsRoutineDispatchAction("TRUE");//sourceId:934450_1_41539
////queryStageCurrentCycleDetailComReqDto.setIsRealTimeaSync("FALSE");//sourceId:934451_1_41539
////queryStageCurrentCycleDetailComReqDto.setIsAppointSimpleMq("FALSE");//sourceId:934452_1_41539
//if(omsEvaluationTemplate!=null){
//      queryStageCurrentCycleDetailComReqDto.setTargetContentName(omsEvaluationTemplate.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:934456_1_41539
//    }
//if(circulationCollectionsRes!=null){
//      queryStageCurrentCycleDetailComReqDto.setObjectId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:934443_1_41539
//queryStageCurrentCycleDetailComReqDto.setAddRuleInfoId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:934445_1_41539
//queryStageCurrentCycleDetailComReqDto.setThemeContentId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:934447_1_41539
//    }
//
//    /*D3-查询常规调度详情(公共)[6630]   */
//    Assert.isNull(queryStageCurrentCycleDetailComReqDto.getTargetContentName(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-目标内容名称不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getTaskDispatchTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-任务调度类型编码不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getDispatchActionTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-任务调度的行为类型编码不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getObjectTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-归属对象类型编码不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getObjectId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-归属对象内容ID不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getAddRuleInfoTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-生成规则信息类型编码不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getAddRuleInfoId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-生成辅助规则信息值不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getThemeContentTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-主题内容类型编码不能为空",false);
//Assert.isNull(queryStageCurrentCycleDetailComReqDto.getThemeContentId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-主题内容ID不能为空",false);
////Assert.isNull(queryStageCurrentCycleDetailComReqDto.getIsCompensateTask(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-是否补偿任务不能为空",false);
////Assert.isNull(queryStageCurrentCycleDetailComReqDto.getIsComplete(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-是否执行完成不能为空",false);
////Assert.isNull(queryStageCurrentCycleDetailComReqDto.getIsRoutineDispatchAction(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-是否常规任务调度不能为空",false);
////Assert.isNull(queryStageCurrentCycleDetailComReqDto.getIsRealTimeaSync(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-是否实时异步调度不能为空",false);
////Assert.isNull(queryStageCurrentCycleDetailComReqDto.getIsAppointSimpleMq(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-查询常规调度详情(公共)-是否固化消息队列不能为空",false);
//      queryStageCurrentCycleDetailComRespDto = queryStageCurrentCycleDetailCom(queryStageCurrentCycleDetailComReqDto)/*vcase invoke 同服务,同domain*/;
//
//
//
//           }
//if((queryStageCurrentCycleDetailComRespDto!= null&& queryStageCurrentCycleDetailComRespDto.getTimingTaskDispatchId() != null )) {
//        //if(D3-查执行周期更新当前周期调度详情(公共).定时任务调度记录ID 值不等于空 )  41272
//
//RefreshStageCurrentCycleEtcComRespDto refreshStageCurrentCycleEtcComRespDto = null;
//    if(queryStageCurrentCycleDetailComRespDto !=null){
//          RefreshStageCurrentCycleEtcComReqDto refreshStageCurrentCycleEtcComReqDto=new RefreshStageCurrentCycleEtcComReqDto();
//  refreshStageCurrentCycleEtcComReqDto.setIsSubCycle("TRUE");//sourceId:927602_1_41274
//refreshStageCurrentCycleEtcComReqDto.setSystemCurrentTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:927605_1_41274
//refreshStageCurrentCycleEtcComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:927604_1_41274
//if(queryStageCurrentCycleDetailComRespDto!=null){
//      refreshStageCurrentCycleEtcComReqDto.setTimingTaskDispatchId(queryStageCurrentCycleDetailComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:927606_1_41274
//    }
//if(circulationCollectionsRes!=null){
//      refreshStageCurrentCycleEtcComReqDto.setTargetId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:927603_1_41274
//    }
//
//    /*D3-3更新周期阶段当前周期等(公共)[3358]   */
//    Assert.isNull(refreshStageCurrentCycleEtcComReqDto.getTimingTaskDispatchId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-定时任务调度记录ID不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto.getIsSubCycle(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-是否子周期不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto.getTargetId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-冗余目标ID不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto.getSystemCurrentTime(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-系统当前时间不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto.getSpaceId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-创建于空间ID不能为空",false);
//      refreshStageCurrentCycleEtcComRespDto = timingTaskService.refreshStageCurrentCycleEtcCom(refreshStageCurrentCycleEtcComReqDto)/*vcase invoke isSameApp*/;
//
//
//
//           }
//RefreshStageCurrentCycleEtcComRespDto refreshStageCurrentCycleEtcComRespDto_1 = null;
//    if(queryStageCurrentCycleDetailComRespDto !=null){
//          RefreshStageCurrentCycleEtcComReqDto refreshStageCurrentCycleEtcComReqDto_1=new RefreshStageCurrentCycleEtcComReqDto();
//  refreshStageCurrentCycleEtcComReqDto_1.setSystemCurrentTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:927611_1_41275
//refreshStageCurrentCycleEtcComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:927610_1_41275
//if(queryStageCurrentCycleDetailComRespDto!=null){
//      refreshStageCurrentCycleEtcComReqDto_1.setTimingTaskDispatchId(queryStageCurrentCycleDetailComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:927612_1_41275
//    }
//if(circulationCollectionsRes!=null){
//      refreshStageCurrentCycleEtcComReqDto_1.setTargetId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:927609_1_41275
//    }
//
//    /*D3-3更新周期阶段当前周期等(公共)[3358]   */
//    Assert.isNull(refreshStageCurrentCycleEtcComReqDto_1.getTimingTaskDispatchId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-定时任务调度记录ID不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto_1.getTargetId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-冗余目标ID不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto_1.getSystemCurrentTime(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-系统当前时间不能为空",false);
//Assert.isNull(refreshStageCurrentCycleEtcComReqDto_1.getSpaceId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3-3更新周期阶段当前周期等(公共)-创建于空间ID不能为空",false);
//      refreshStageCurrentCycleEtcComRespDto_1 = timingTaskService.refreshStageCurrentCycleEtcCom(refreshStageCurrentCycleEtcComReqDto_1)/*vcase invoke isSameApp*/;
//
//
//
//           }
//ImplementGeneralTaskPlanProcessingComRespDto implementGeneralTaskPlanProcessingComRespDto = null;
//    if(queryStageCurrentCycleDetailComRespDto !=null){
//          ImplementGeneralTaskPlanProcessingComReqDto implementGeneralTaskPlanProcessingComReqDto=new ImplementGeneralTaskPlanProcessingComReqDto();
//  implementGeneralTaskPlanProcessingComReqDto.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:946988_1_41801
//implementGeneralTaskPlanProcessingComReqDto.setDispatchActionTypeCode("STAGE_CURRENT_CYCLE_ETC");//sourceId:946989_1_41801
//implementGeneralTaskPlanProcessingComReqDto.setObjectTypeCode("OMS_TARGET");//sourceId:946990_1_41801
//implementGeneralTaskPlanProcessingComReqDto.setIsCompensateTask("FALSE");//sourceId:946992_1_41801
//implementGeneralTaskPlanProcessingComReqDto.setIsComplete("TRUE");//sourceId:946993_1_41801
//if(queryStageCurrentCycleDetailComRespDto!=null){
//      implementGeneralTaskPlanProcessingComReqDto.setTimingTaskDispatchId(queryStageCurrentCycleDetailComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:946995_1_41801
//    }
//if(circulationCollectionsRes!=null){
//      implementGeneralTaskPlanProcessingComReqDto.setObjectId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:946991_1_41801
//    }
//if(reqDto!=null){
//      implementGeneralTaskPlanProcessingComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:946994_1_41801
//    }
//
//    /*D3执行常规调度任务处理(公共)[5413]   */
//    Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getTimingTaskDispatchId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-定时任务调度记录ID不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getTaskDispatchTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-任务调度类型编码不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getDispatchActionTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-任务调度的行为类型编码不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getObjectTypeCode(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-归属对象类型编码不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getObjectId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-归属对象内容ID不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getIsCompensateTask(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-是否补偿任务不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getIsComplete(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-是否执行完成不能为空",false);
//Assert.isNull(implementGeneralTaskPlanProcessingComReqDto.getSpaceId(),"D3-执行周期当前子周期及末级周期调度(公共)-D3执行常规调度任务处理(公共)-创建于空间ID不能为空",false);
//      implementGeneralTaskPlanProcessingComRespDto = taskGenService.implementGeneralTaskPlanProcessingCom(implementGeneralTaskPlanProcessingComReqDto)/*vcase invoke isSameApp*/;
//
//
//
//           }
//      }
//      }
//// TODO: 2023/8/22
//else if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getTargetPgsStatus() !=null && circulationCollectionsRes.getTargetPgsStatus().equals("HAS_ENDED"))){
//       //elseif(M3执行目标【循环开始】.目标进展状态 等于 已结束)  41257
//
////processBranchName:继续循环 ,processBranchId:41258
//        continue;
//    }
////ModelCode: circulationEnd
//        }
//
//      }
////virtualUsage M3异步结束  41230
//      //ModelCode: asynchronizationEnd
//        return "";
//    }
//};
//CommonFunctionHelper.asynExcute(call);
//ImplementStageCurrentCycleEtcComRespDto retData = new ImplementStageCurrentCycleEtcComRespDto();
//
//

  
  
return null;
  }
/**
   * D3-执行目标完成状态校验(公共)[6620]
   * gen by moon at 10/3/2023, 6:42:33 PM
   */
  @Trace(operationName = "D3-执行目标完成状态校验(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCheckTargetIsDoneComRespDto implementCheckTargetIsDoneCom(ImplementCheckTargetIsDoneComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 =null;
//virtualUsage 约定：是  41397
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setTureOrFalse("TRUE");//sourceId:930822_1_41397

    /*约定：是[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTureOrFalse(),"D3-执行目标完成状态校验(公共)-约定：是-是否不能为空",false);
      receptionServiceRes = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq);



//virtualUsage 约定：否  41398
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:930826_1_41398

    /*约定：否[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTureOrFalse(),"D3-执行目标完成状态校验(公共)-约定：否-是否不能为空",false);
      receptionServiceRes_2 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_1);



//virtualUsage 3-3-01查目标详情  41399
      OmsTarget omsTarget = null;
    QueryTargetDetailReq queryTargetDetailReq=new QueryTargetDetailReq();
  queryTargetDetailReq.setIsArchive("FALSE");//sourceId:930934_1_41399
if(reqDto!=null){
      queryTargetDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:930933_1_41399
    }

    /*3-3-01查目标详情[2488]   */
    Assert.isNull(queryTargetDetailReq.getTargetId(),"D3-执行目标完成状态校验(公共)-3-3-01查目标详情-目标ID不能为空",false);
Assert.isNull(queryTargetDetailReq.getIsArchive(),"D3-执行目标完成状态校验(公共)-3-3-01查目标详情-是否存档不能为空",false);
      omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTarget!= null&&  omsTarget.getTargetPgsStatus() !=null && omsTarget.getTargetPgsStatus().equals("NOTSTARTED")||omsTarget!= null&&  omsTarget.getTargetPgsStatus() !=null && omsTarget.getTargetPgsStatus().equals("ONGOING"))) {
        //if((3-3-01查目标详情.目标进展状态 等于 未开始 or 3-3-01查目标详情.目标进展状态 等于 进行中))  41400

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:930946_1_41401
    }

    /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getTureOrFalse(),"D3-执行目标完成状态校验(公共)-约定出参：是否可用-是否不能为空",false);
      receptionServiceRes_4 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_2);


      receptionServiceRes_5 = receptionServiceRes_4;
      }
else if((omsTarget!= null&&  omsTarget.getTargetPgsStatus() !=null && omsTarget.getTargetPgsStatus().equals("FINISHED"))){
       //elseif(3-3-01查目标详情.目标进展状态 等于 已结束)  41402

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_3.setTureOrFalse(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:930946_1_41403
    }

    /*约定出参：是否可用[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getTureOrFalse(),"D3-执行目标完成状态校验(公共)-约定出参：是否可用-是否不能为空",false);
      receptionServiceRes_6 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_5 = receptionServiceRes_6;
    }
ImplementCheckTargetIsDoneComRespDto retData = new ImplementCheckTargetIsDoneComRespDto();
  if(receptionServiceRes_5!=null){
      retData.setTureOrFalse(receptionServiceRes_5.getTureOrFalse());//SimpleFieldAssign//sourceId:930947_1
    }




return retData;
  }
/**
   * D3-查询常规调度详情(公共)[6630]
   * gen by moon at 10/2/2023, 5:16:50 PM
   */
  @Trace(operationName = "D3-查询常规调度详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryStageCurrentCycleDetailComRespDto queryStageCurrentCycleDetailCom(QueryStageCurrentCycleDetailComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 =null;
//virtualUsage 3-2-09查询定时任务调度详情  41533
      OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch = null;
    QueryTimerTaskPlanDetailReq queryTimerTaskPlanDetailReq=new QueryTimerTaskPlanDetailReq();
  queryTimerTaskPlanDetailReq.setIsComplete("FALSE");//sourceId:934387_1_41533
queryTimerTaskPlanDetailReq.setIsCompensateTask("FALSE");//sourceId:934386_1_41533
  if(reqDto!=null){
      queryTimerTaskPlanDetailReq.setTaskDispatchTypeCode(reqDto.getTaskDispatchTypeCode());//SimpleFieldAssign//sourceId:934378_1_41533
queryTimerTaskPlanDetailReq.setDispatchActionTypeCode(reqDto.getDispatchActionTypeCode());//SimpleFieldAssign//sourceId:934379_1_41533
queryTimerTaskPlanDetailReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:934381_1_41533
queryTimerTaskPlanDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:934385_1_41533
    }

    /*3-2-09查询定时任务调度详情[3187]   */
    Assert.isNull(queryTimerTaskPlanDetailReq.getTaskDispatchTypeCode(),"D3-查询常规调度详情(公共)-3-2-09查询定时任务调度详情-任务调度类型编码不能为空",false);
Assert.isNull(queryTimerTaskPlanDetailReq.getDispatchActionTypeCode(),"D3-查询常规调度详情(公共)-3-2-09查询定时任务调度详情-任务调度的行为类型编码不能为空",false);
Assert.isNull(queryTimerTaskPlanDetailReq.getObjectId(),"D3-查询常规调度详情(公共)-3-2-09查询定时任务调度详情-归属对象内容ID不能为空",false);
Assert.isNull(queryTimerTaskPlanDetailReq.getThemeContentId(),"D3-查询常规调度详情(公共)-3-2-09查询定时任务调度详情-主题内容ID不能为空",false);
Assert.isNull(queryTimerTaskPlanDetailReq.getIsComplete(),"D3-查询常规调度详情(公共)-3-2-09查询定时任务调度详情-是否执行完成不能为空",false);
Assert.isNull(queryTimerTaskPlanDetailReq.getIsCompensateTask(),"D3-查询常规调度详情(公共)-3-2-09查询定时任务调度详情-是否补偿任务不能为空",false);
      omsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanDetail(queryTimerTaskPlanDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetTimingTaskDispatch == null )) {
        //if(3-2-09查询定时任务调度详情.出参 值等于空 )  41534

AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto = null;
    AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto=new AddTimerTaskPlanComReqDto();
  addTimerTaskPlanComReqDto.setIsRealTimeaSync("FALSE");//sourceId:934436_1_41535
addTimerTaskPlanComReqDto.setIsCompensateTask("FALSE");//sourceId:934425_1_41535
addTimerTaskPlanComReqDto.setIsComplete("FALSE");//sourceId:934435_1_41535
addTimerTaskPlanComReqDto.setIsAppointSimpleMq("FALSE");//sourceId:934434_1_41535
  addTimerTaskPlanComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:934437_1_41535
addTimerTaskPlanComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:934438_1_41535
addTimerTaskPlanComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:934439_1_41535
if(reqDto!=null){
      addTimerTaskPlanComReqDto.setTargetContentName(reqDto.getTargetContentName());//SimpleFieldAssign//sourceId:934491_1_41535
addTimerTaskPlanComReqDto.setTaskName(reqDto.getTaskName());//SimpleFieldAssign//sourceId:946958_1_41535
addTimerTaskPlanComReqDto.setTaskDispatchTypeCode(reqDto.getTaskDispatchTypeCode());//SimpleFieldAssign//sourceId:934427_1_41535
addTimerTaskPlanComReqDto.setDispatchActionTypeCode(reqDto.getDispatchActionTypeCode());//SimpleFieldAssign//sourceId:934426_1_41535
addTimerTaskPlanComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:934428_1_41535
addTimerTaskPlanComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:934429_1_41535
addTimerTaskPlanComReqDto.setAddRuleInfoTypeCode(reqDto.getAddRuleInfoTypeCode());//SimpleFieldAssign//sourceId:934430_1_41535
addTimerTaskPlanComReqDto.setAddRuleInfoId(reqDto.getAddRuleInfoId());//SimpleFieldAssign//sourceId:934431_1_41535
addTimerTaskPlanComReqDto.setThemeContentTypeCode(reqDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:934432_1_41535
addTimerTaskPlanComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:934433_1_41535
addTimerTaskPlanComReqDto.setStandbyField1(reqDto.getStandbyField1());//SimpleFieldAssign//sourceId:1011375_1_41535
addTimerTaskPlanComReqDto.setStandbyField2(reqDto.getStandbyField2());//SimpleFieldAssign//sourceId:1011376_1_41535
    }

    /*D3新增定时任务调度(公共)[4995]   */
    Assert.isNull(addTimerTaskPlanComReqDto.getTaskDispatchTypeCode(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-任务调度类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getDispatchActionTypeCode(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-任务调度的行为类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getObjectTypeCode(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-归属对象类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getObjectId(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-归属对象内容ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentTypeCode(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-主题内容类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentId(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-主题内容ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsRealTimeaSync(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-是否实时异步调度不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsCompensateTask(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-是否补偿任务不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsComplete(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-是否执行完成不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsAppointSimpleMq(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-是否固化消息队列不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getOperationInductionId(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-操作人就职记录ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getSpaceId(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-创建于空间ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getAppId(),"D3-查询常规调度详情(公共)-D3新增定时任务调度(公共)-创建于联盟应用ID不能为空",false);
      addTimerTaskPlanComRespDto = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    if(addTimerTaskPlanComRespDto !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(addTimerTaskPlanComRespDto!=null){
      receptionServiceReq.setTimingTaskDispatchId(addTimerTaskPlanComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:934368_1_41536
    }

    /*约定出参：定时任务调度记录ID[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTimingTaskDispatchId(),"D3-查询常规调度详情(公共)-约定出参：定时任务调度记录ID-定时任务调度记录ID不能为空",false);
      receptionServiceRes = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((omsTargetTimingTaskDispatch != null )){
       //elseif(3-2-09查询定时任务调度详情.出参 值不等于空 )  41537

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    if(omsTargetTimingTaskDispatch !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(omsTargetTimingTaskDispatch!=null){
      receptionServiceReq_1.setTimingTaskDispatchId(omsTargetTimingTaskDispatch.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:934368_1_41538
    }

    /*约定出参：定时任务调度记录ID[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTimingTaskDispatchId(),"D3-查询常规调度详情(公共)-约定出参：定时任务调度记录ID-定时任务调度记录ID不能为空",false);
      receptionServiceRes_2 = nbConventionalScheduling.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
QueryStageCurrentCycleDetailComRespDto retData = new QueryStageCurrentCycleDetailComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setTimingTaskDispatchId(receptionServiceRes_1.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:934371_1
    }




return retData;
  }
/**
   * D3-执行任务逾期调度(公共)[6604]
   * gen by moon at 1/20/2024, 2:02:20 PM
   */
  @Trace(operationName = "D3-执行任务逾期调度(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTaskOverdueEtcComRespDto implementTaskOverdueEtcCom(ImplementTaskOverdueEtcComReqDto reqDto){


      //virtualUsage M3异步开始  41295
//      ModelCode: asynchronizationStart
Callable<String> call = new Callable<String>() {

    @Override
    public String call() throws Exception {
        //执行方法
//virtualUsage M3执行业务应用公共字段推送内存（特殊方法）  41321
      //ModelCode: publicFieldCache
        ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
    ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq=new ImplementBizPublicFieldPushMemoryReqDto();
  if(reqDto!=null){
      publicFieldCacheReq.setCreateInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:929090_1_41321
publicFieldCacheReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:929091_1_41321
publicFieldCacheReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:929092_1_41321
    }

    /*M3执行业务应用公共字段推送内存（特殊方法）[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
    Assert.isNull(publicFieldCacheReq.getCreateInductionId(),"D3-执行任务逾期调度(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建人就职记录ID 不能为空",false);
Assert.isNull(publicFieldCacheReq.getSpaceId(),"D3-执行任务逾期调度(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建于空间ID不能为空",false);
Assert.isNull(publicFieldCacheReq.getAppId(),"D3-执行任务逾期调度(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建于联盟应用ID不能为空",false);
      publicFieldCacheRes = nbConventionalScheduling.implementBizPublicFieldPushMemory(publicFieldCacheReq);



if((reqDto!= null&&  reqDto.getReportingTaskList() !=null && reqDto.getReportingTaskList().size()>0)) {
        //if(D3-执行任务逾期调度(公共).汇报任务列表数据集条数 大于 0)  41298

//ModelCode: circulationCollections
        for (ReportingTaskDto circulationCollectionsRes: reqDto.getReportingTaskList()){

ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto = null;
    ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto=new ImplementConcurrentBehaviorThemeLockComReqDto();
  implementConcurrentBehaviorThemeLockComReqDto.setBehaviorThemeLockCode("REPORT_TASK_OVERDUE_STATUS_MSG_NUM_SWIPES");//sourceId:1490374_1_59777
implementConcurrentBehaviorThemeLockComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1490379_1_59777
implementConcurrentBehaviorThemeLockComReqDto.setTimeUnitType("MINUTES");//sourceId:1490380_1_59777
implementConcurrentBehaviorThemeLockComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1490382_1_59777
implementConcurrentBehaviorThemeLockComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1490381_1_59777
if(circulationCollectionsRes!=null){
      implementConcurrentBehaviorThemeLockComReqDto.setCommPrimaryKey(circulationCollectionsRes.getTaskId());//SimpleFieldAssign//sourceId:1490375_1_59777
    }

    /*D3执行并发行为主题上锁(公共)[8296]   */
    Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getBehaviorThemeLockCode(),"D3-执行任务逾期调度(公共)-D3执行并发行为主题上锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getCommPrimaryKey(),"D3-执行任务逾期调度(公共)-D3执行并发行为主题上锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getDuration(),"D3-执行任务逾期调度(公共)-D3执行并发行为主题上锁(公共)-锁定时长不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getTimeUnitType(),"D3-执行任务逾期调度(公共)-D3执行并发行为主题上锁(公共)-时间单位类型不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getHandlingMethodConcurrentLockFailure(),"D3-执行任务逾期调度(公共)-D3执行并发行为主题上锁(公共)-并发上锁失败处理方式不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getPreventConcurrentLockingUnlocking(),"D3-执行任务逾期调度(公共)-D3执行并发行为主题上锁(公共)-防并发上锁or解锁不能为空",false);
      implementConcurrentBehaviorThemeLockComRespDto = interfaceModeService.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto)/*vcase invoke isSameApp*/;



OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getParentEntityId());//SimpleFieldAssign//sourceId:1469713_1_58813
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1469714_1_58813
    }

    /*3-3-09查当前牌目标进展状态是否完成[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-执行任务逾期调度(公共)-3-3-09查当前牌目标进展状态是否完成-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-执行任务逾期调度(公共)-3-3-09查当前牌目标进展状态是否完成-冗余评价模板ID不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaluationObjectTargetCycle== null||  omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId() ==null,"找不到数据，系统异常",false);


if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getTaskStatus() !=null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("NOT_AT_THE")||omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getTaskStatus() !=null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("ONGOING"))&&(implementConcurrentBehaviorThemeLockComRespDto!= null&&  implementConcurrentBehaviorThemeLockComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcurrentBehaviorThemeLockComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if((3-3-09查当前牌目标进展状态是否完成.目标周期任务进展状态 等于 未开始 or 3-3-09查当前牌目标进展状态是否完成.目标周期任务进展状态 等于 进行中) and D3执行并发行为主题上锁(公共).防并发上锁情况 等于 空上锁成功)  58814

RefreshReportTaskStatusMsgAndMsgNumComRespDto refreshReportTaskStatusMsgAndMsgNumComRespDto = null;
    RefreshReportTaskStatusMsgAndMsgNumComReqDto refreshReportTaskStatusMsgAndMsgNumComReqDto=new RefreshReportTaskStatusMsgAndMsgNumComReqDto();
  refreshReportTaskStatusMsgAndMsgNumComReqDto.setStatusBizOptType("AUTO_ORDER");//sourceId:1468467_1_58815
refreshReportTaskStatusMsgAndMsgNumComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1468469_1_58815
refreshReportTaskStatusMsgAndMsgNumComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1468470_1_58815
if(circulationCollectionsRes!=null){
      refreshReportTaskStatusMsgAndMsgNumComReqDto.setTaskId(circulationCollectionsRes.getTaskId());//SimpleFieldAssign//sourceId:1468468_1_58815
    }

    /*D3-更新汇报任务状态及消息与数量(公共)[8263]   */
    Assert.isNull(refreshReportTaskStatusMsgAndMsgNumComReqDto.getStatusBizOptType(),"D3-执行任务逾期调度(公共)-D3-更新汇报任务状态及消息与数量(公共)-状态业务操作类型不能为空",false);
Assert.isNull(refreshReportTaskStatusMsgAndMsgNumComReqDto.getTaskId(),"D3-执行任务逾期调度(公共)-D3-更新汇报任务状态及消息与数量(公共)-任务ID不能为空",false);
Assert.isNull(refreshReportTaskStatusMsgAndMsgNumComReqDto.getSpaceId(),"D3-执行任务逾期调度(公共)-D3-更新汇报任务状态及消息与数量(公共)-创建于空间ID不能为空",false);
Assert.isNull(refreshReportTaskStatusMsgAndMsgNumComReqDto.getAppId(),"D3-执行任务逾期调度(公共)-D3-更新汇报任务状态及消息与数量(公共)-创建于联盟应用ID不能为空",false);
      refreshReportTaskStatusMsgAndMsgNumComRespDto = taskService.refreshReportTaskStatusMsgAndMsgNumCom(refreshReportTaskStatusMsgAndMsgNumComReqDto)/*vcase invoke isSameApp*/;



ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto_2 = null;
    ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto_1=new ImplementConcurrentBehaviorThemeLockComReqDto();
  implementConcurrentBehaviorThemeLockComReqDto_1.setBehaviorThemeLockCode("REPORT_TASK_OVERDUE_STATUS_MSG_NUM_SWIPES");//sourceId:1490396_1_59878
implementConcurrentBehaviorThemeLockComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1490398_1_59878
implementConcurrentBehaviorThemeLockComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1490399_1_59878
if(circulationCollectionsRes!=null){
      implementConcurrentBehaviorThemeLockComReqDto_1.setCommPrimaryKey(circulationCollectionsRes.getTaskId());//SimpleFieldAssign//sourceId:1490397_1_59878
    }

    /*D3执行并发行为主题解锁(公共)[8296]   */
    Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getBehaviorThemeLockCode(),"D3-执行任务逾期调度(公共)-D3执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getCommPrimaryKey(),"D3-执行任务逾期调度(公共)-D3执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getPreventConcurrentLockingUnlocking(),"D3-执行任务逾期调度(公共)-D3执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getWhetherUnlockBulk(),"D3-执行任务逾期调度(公共)-D3执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcurrentBehaviorThemeLockComRespDto_2 = interfaceModeService.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto_1)/*vcase invoke isSameApp*/;



      }
//ModelCode: circulationEnd
        }

      }
//virtualUsage M3异步结束  41296
      //ModelCode: asynchronizationEnd
        return "";
    }
};
CommonFunctionHelper.asynExcute(call);
ImplementTaskOverdueEtcComRespDto retData = new ImplementTaskOverdueEtcComRespDto();





return retData;
  }
/**
   * D3-执行四棵树偏差天数调度&目标周期进展状态(公共)[6602]
   * gen by moon at 4/7/2024, 3:24:28 PM
   */
  @Trace(operationName = "D3-执行四棵树偏差天数调度&目标周期进展状态(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementFourTreeDeviationDaysEtcScheduleComRespDto implementFourTreeDeviationDaysEtcScheduleCom(ImplementFourTreeDeviationDaysEtcScheduleComReqDto reqDto){


      //virtualUsage M3异步开始（特殊方法）  41276
      //ModelCode: asynchronizationStart
Callable<String> call = new Callable<String>() {

    @Override
    public String call() throws Exception {
        //执行方法
//virtualUsage M3执行业务应用公共字段推送内存（特殊方法）  41324
      //ModelCode: publicFieldCache
        ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
    ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq=new ImplementBizPublicFieldPushMemoryReqDto();
  if(reqDto!=null){
      publicFieldCacheReq.setCreateInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:929103_1_41324
publicFieldCacheReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:929104_1_41324
publicFieldCacheReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:929105_1_41324
    }

    /*M3执行业务应用公共字段推送内存（特殊方法）[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */

      publicFieldCacheRes = nbConventionalScheduling.implementBizPublicFieldPushMemory(publicFieldCacheReq);



//virtualUsage M3执行目标内容ID发牌【循环开始】  49315
//ModelCode: circulationCollections
        for (TargetContentDto circulationCollectionsRes: reqDto.getTargetContentList()){

//virtualUsage 3-3-09查目标周期详情（获取目标内容信息）  49317
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1151296_1_49317
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1151294_1_49317
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1151295_1_49317
    }

    /*3-3-09查目标周期详情（获取目标内容信息）[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查目标周期详情（获取目标内容信息）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查目标周期详情（获取目标内容信息）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查目标周期详情（获取目标内容信息）-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage D2对比当前时间与操作时间（用于判断是否需要继续执行）  49318
ImplementComparisonOfMultipleTimeTypesComRespDto implementComparisonOfMultipleTimeTypesComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
    ImplementComparisonOfMultipleTimeTypesComReqDto implementComparisonOfMultipleTimeTypesComReqDto=new ImplementComparisonOfMultipleTimeTypesComReqDto();
  implementComparisonOfMultipleTimeTypesComReqDto.setTimeUnitType("DAY");//sourceId:1118327_1_49318
implementComparisonOfMultipleTimeTypesComReqDto.setCaluStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1118329_1_49318
if(omsEvaluationObjectTargetCycle!=null){
      implementComparisonOfMultipleTimeTypesComReqDto.setCompareTime(omsEvaluationObjectTargetCycle.getOperateTime());//SimpleFieldAssign//sourceId:1118328_1_49318
    }

    /*D2对比当前时间与操作时间（用于判断是否需要继续执行）[7376]   */
    Assert.isNull(implementComparisonOfMultipleTimeTypesComReqDto.getTimeUnitType(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D2对比当前时间与操作时间（用于判断是否需要继续执行）-时间单位类型不能为空",false);
Assert.isNull(implementComparisonOfMultipleTimeTypesComReqDto.getCaluStartTime(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D2对比当前时间与操作时间（用于判断是否需要继续执行）-参照时间不能为空",false);
Assert.isNull(implementComparisonOfMultipleTimeTypesComReqDto.getCompareTime(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D2对比当前时间与操作时间（用于判断是否需要继续执行）-比较时间不能为空",false);
      implementComparisonOfMultipleTimeTypesComRespDto = fwCompInterfaceModeClient.implementComparisonOfMultipleTimeTypesCom(implementComparisonOfMultipleTimeTypesComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage D3执行并发行为主题上锁(公共)  59847
      ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto=new ImplementConcurrentBehaviorThemeLockComReqDto();
  implementConcurrentBehaviorThemeLockComReqDto.setBehaviorThemeLockCode("FOUR_TREE_DEVIATION_DAYS_DISPATCH_SWIPES");//sourceId:1491008_1_59847
implementConcurrentBehaviorThemeLockComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1491011_1_59847
implementConcurrentBehaviorThemeLockComReqDto.setTimeUnitType("MINUTES");//sourceId:1491012_1_59847
implementConcurrentBehaviorThemeLockComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1491013_1_59847
implementConcurrentBehaviorThemeLockComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1491014_1_59847
if(omsEvaluationObjectTargetCycle!=null){
      implementConcurrentBehaviorThemeLockComReqDto.setCommPrimaryKey(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1491009_1_59847
implementConcurrentBehaviorThemeLockComReqDto.setCustomField1(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1491010_1_59847
    }

    /*D3执行并发行为主题上锁(公共)[8296]   */
    Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getBehaviorThemeLockCode(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getCommPrimaryKey(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getCustomField1(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-自定义字段1不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getDuration(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-锁定时长不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getTimeUnitType(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-时间单位类型不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getHandlingMethodConcurrentLockFailure(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-并发上锁失败处理方式不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto.getPreventConcurrentLockingUnlocking(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题上锁(公共)-防并发上锁or解锁不能为空",false);
      implementConcurrentBehaviorThemeLockComRespDto = interfaceModeService.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto)/*vcase invoke isSameApp*/;



           }
if((implementComparisonOfMultipleTimeTypesComRespDto!= null&&  implementComparisonOfMultipleTimeTypesComRespDto.getTimeCompareResult() !=null && implementComparisonOfMultipleTimeTypesComRespDto.getTimeCompareResult().equals("BEFORE")&&implementConcurrentBehaviorThemeLockComRespDto!= null&&  implementConcurrentBehaviorThemeLockComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcurrentBehaviorThemeLockComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if((D2对比当前时间与操作时间（用于判断是否需要继续执行）.时间比较结果 等于 之前（小于） and D3执行并发行为主题上锁(公共).防并发上锁情况 等于 空上锁成功))  49319

if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getTaskStatus() !=null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("NOT_AT_THE")||omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getTaskStatus() !=null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("ONGOING"))) {
        //if((3-3-09查目标周期详情（获取目标内容信息）.目标周期任务进展状态 等于 未开始 or 3-3-09查目标周期详情（获取目标内容信息）.目标周期任务进展状态 等于 进行中))  49321

RefreshFourTreeDeviationDaysEtcComRespDto refreshFourTreeDeviationDaysEtcComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          RefreshFourTreeDeviationDaysEtcComReqDto refreshFourTreeDeviationDaysEtcComReqDto=new RefreshFourTreeDeviationDaysEtcComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      refreshFourTreeDeviationDaysEtcComReqDto.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1151308_1_49322
refreshFourTreeDeviationDaysEtcComReqDto.setSpaceId(omsEvaluationObjectTargetCycle.getSpaceId());//SimpleFieldAssign//sourceId:1151309_1_49322
    }

    /*D3-3更新四棵树偏差天数等数据(公共)[3361]   */
    Assert.isNull(refreshFourTreeDeviationDaysEtcComReqDto.getEvaObjTargetCycleId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3-3更新四棵树偏差天数等数据(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(refreshFourTreeDeviationDaysEtcComReqDto.getSpaceId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3-3更新四棵树偏差天数等数据(公共)-创建于空间ID不能为空",false);
      refreshFourTreeDeviationDaysEtcComRespDto = timingTaskService.refreshFourTreeDeviationDaysEtcCom(refreshFourTreeDeviationDaysEtcComReqDto)/*vcase invoke isSameApp*/;



           }
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentTypeCode("TARGET");//sourceId:1151402_1_49329
queryEvaObjTargetCycleDetailReq_1.setIsParentCycle("TRUE");//sourceId:1151403_1_49329
queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:1151405_1_49329
if(omsEvaluationObjectTargetCycle!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1151400_1_49329
queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1151401_1_49329
queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1151404_1_49329
    }

    /*3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentTypeCode(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsParentCycle(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-3-3-09查根节点目标周期简称（用于增目标更新当前周期及下一周期调度）-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



    }
if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode() !=null && omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")||omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode() !=null && omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
        //if((3-3-09查目标周期详情（获取目标内容信息）.关联目标内容类型编码 等于 目标分类 or 3-3-09查目标周期详情（获取目标内容信息）.关联目标内容类型编码 等于 指标))  49325

ImplementInitializeUpdateTargetContCurrentCycleComRespDto implementInitializeUpdateTargetContCurrentCycleComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementInitializeUpdateTargetContCurrentCycleComReqDto implementInitializeUpdateTargetContCurrentCycleComReqDto=new ImplementInitializeUpdateTargetContCurrentCycleComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetContentName(omsEvaluationObjectTargetCycle.getCyclelAlias());//SimpleFieldAssign//sourceId:1151312_1_49326
implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetCycleContentTypeCode(omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1151315_1_49326
implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1151316_1_49326
implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1151314_1_49326
implementInitializeUpdateTargetContCurrentCycleComReqDto.setEvaluationTemplateId(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1151313_1_49326
    }

    /*D3执行更新目标分类或指标当前及下一周期(公共)[7473]   */
    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetContentName(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标分类或指标当前及下一周期(公共)-目标内容名称不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetCycleContentTypeCode(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标分类或指标当前及下一周期(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetCycleContentId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标分类或指标当前及下一周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标分类或指标当前及下一周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getEvaluationTemplateId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标分类或指标当前及下一周期(公共)-冗余评价模板ID不能为空",false);
      implementInitializeUpdateTargetContCurrentCycleComRespDto = targetContentService.implementInitializeUpdateTargetContCurrentCycleCom(implementInitializeUpdateTargetContCurrentCycleComReqDto)/*vcase invoke isSameApp*/;



    }
ImplementInitializeUpdateTargetContCurrentCycleComRespDto implementInitializeUpdateTargetContCurrentCycleComRespDto_1 = null;
    if(omsEvaluationObjectTargetCycle_2 !=null&&omsEvaluationObjectTargetCycle !=null){
          ImplementInitializeUpdateTargetContCurrentCycleComReqDto implementInitializeUpdateTargetContCurrentCycleComReqDto_1=new ImplementInitializeUpdateTargetContCurrentCycleComReqDto();
  implementInitializeUpdateTargetContCurrentCycleComReqDto_1.setTargetCycleContentTypeCode("TARGET");//sourceId:1151321_1_49327
if(omsEvaluationObjectTargetCycle_2!=null){
      implementInitializeUpdateTargetContCurrentCycleComReqDto_1.setTargetContentName(omsEvaluationObjectTargetCycle_2.getCyclelAlias());//SimpleFieldAssign//sourceId:1151318_1_49327
    }
if(omsEvaluationObjectTargetCycle!=null){
      implementInitializeUpdateTargetContCurrentCycleComReqDto_1.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1151322_1_49327
implementInitializeUpdateTargetContCurrentCycleComReqDto_1.setTargetId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1151320_1_49327
implementInitializeUpdateTargetContCurrentCycleComReqDto_1.setEvaluationTemplateId(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1151319_1_49327
    }

    /*D3执行更新目标当前及下一周期(公共)[7473]   */
    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_1.getTargetContentName(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-目标内容名称不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_1.getTargetCycleContentTypeCode(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_1.getTargetCycleContentId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_1.getTargetId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_1.getEvaluationTemplateId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-冗余评价模板ID不能为空",false);
      implementInitializeUpdateTargetContCurrentCycleComRespDto_1 = targetContentService.implementInitializeUpdateTargetContCurrentCycleCom(implementInitializeUpdateTargetContCurrentCycleComReqDto_1)/*vcase invoke isSameApp*/;



           }
      }
else if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode() !=null && omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode().equals("TARGET"))){
       //elseif(3-3-09查目标周期详情（获取目标内容信息）.关联目标内容类型编码 等于 目标)  49330

ImplementInitializeUpdateTargetContCurrentCycleComRespDto implementInitializeUpdateTargetContCurrentCycleComRespDto_2 = null;
    if(omsEvaluationObjectTargetCycle_2 !=null&&omsEvaluationObjectTargetCycle !=null){
          ImplementInitializeUpdateTargetContCurrentCycleComReqDto implementInitializeUpdateTargetContCurrentCycleComReqDto_2=new ImplementInitializeUpdateTargetContCurrentCycleComReqDto();
  implementInitializeUpdateTargetContCurrentCycleComReqDto_2.setTargetCycleContentTypeCode("TARGET");//sourceId:1151321_1_49331
if(omsEvaluationObjectTargetCycle_2!=null){
      implementInitializeUpdateTargetContCurrentCycleComReqDto_2.setTargetContentName(omsEvaluationObjectTargetCycle_2.getCyclelAlias());//SimpleFieldAssign//sourceId:1151318_1_49331
    }
if(omsEvaluationObjectTargetCycle!=null){
      implementInitializeUpdateTargetContCurrentCycleComReqDto_2.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1151322_1_49331
implementInitializeUpdateTargetContCurrentCycleComReqDto_2.setTargetId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1151320_1_49331
implementInitializeUpdateTargetContCurrentCycleComReqDto_2.setEvaluationTemplateId(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1151319_1_49331
    }

    /*D3执行更新目标当前及下一周期(公共)[7473]   */
    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_2.getTargetContentName(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-目标内容名称不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_2.getTargetCycleContentTypeCode(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_2.getTargetCycleContentId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_2.getTargetId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto_2.getEvaluationTemplateId(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行更新目标当前及下一周期(公共)-冗余评价模板ID不能为空",false);
      implementInitializeUpdateTargetContCurrentCycleComRespDto_2 = targetContentService.implementInitializeUpdateTargetContCurrentCycleCom(implementInitializeUpdateTargetContCurrentCycleComReqDto_2)/*vcase invoke isSameApp*/;



           }
      }
      }
      }
//virtualUsage D3执行并发行为主题解锁(公共)  59848
      ImplementConcurrentBehaviorThemeLockComRespDto implementConcurrentBehaviorThemeLockComRespDto_2 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementConcurrentBehaviorThemeLockComReqDto implementConcurrentBehaviorThemeLockComReqDto_1=new ImplementConcurrentBehaviorThemeLockComReqDto();
  implementConcurrentBehaviorThemeLockComReqDto_1.setBehaviorThemeLockCode("FOUR_TREE_DEVIATION_DAYS_DISPATCH_SWIPES");//sourceId:1490997_1_59848
implementConcurrentBehaviorThemeLockComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1491004_1_59848
implementConcurrentBehaviorThemeLockComReqDto_1.setWhetherUnlockBulk("FALSE");//sourceId:1491007_1_59848
if(omsEvaluationObjectTargetCycle!=null){
      implementConcurrentBehaviorThemeLockComReqDto_1.setCommPrimaryKey(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1490998_1_59848
implementConcurrentBehaviorThemeLockComReqDto_1.setCustomField1(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1490999_1_59848
    }

    /*D3执行并发行为主题解锁(公共)[8296]   */
    Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getBehaviorThemeLockCode(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题解锁(公共)-行为主题锁不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getCommPrimaryKey(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题解锁(公共)-通用主键ID不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getCustomField1(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题解锁(公共)-自定义字段1不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getPreventConcurrentLockingUnlocking(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题解锁(公共)-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcurrentBehaviorThemeLockComReqDto_1.getWhetherUnlockBulk(),"D3-执行四棵树偏差天数调度&目标周期进展状态(公共)-D3执行并发行为主题解锁(公共)-是否批量解锁不能为空",false);
      implementConcurrentBehaviorThemeLockComRespDto_2 = interfaceModeService.implementConcurrentBehaviorThemeLockCom(implementConcurrentBehaviorThemeLockComReqDto_1)/*vcase invoke isSameApp*/;



      }
//virtualUsage M3-执行【循环结束】  49316
//ModelCode: circulationEnd
        }

//virtualUsage M3异步结束（特殊方法）  41277
      //ModelCode: asynchronizationEnd
        return "";
    }
};
CommonFunctionHelper.asynExcute(call);
ImplementFourTreeDeviationDaysEtcScheduleComRespDto retData = new ImplementFourTreeDeviationDaysEtcScheduleComRespDto();





return retData;
  }
  //
}
